/**
 函数式接口		参数类型		返回类型		用途
Consumer<T>    	T			Void		对类型为T的对象应用操作，包含方法：void accept(T t）
Supplier<T> 	无			T			返回类型为T的对象，包含方法:T get()
Function<T,R>	T			R			对类型为T的对象应用操作，并返回结果。结果是R类型的对象。包含方法：R apply(T t）
Predicate<T>	T			boolean		确定类型为T的对象是否满足某约束，并返回BOOLEAN值。包含方法：Boolean test(T t）	
 */
/*
package com.leo.第九章_集合;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.function.Consumer;

public class U9_L5_JDK8_4大核心接口_Consumer {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//1.如何添加元素
		odd_even();
		//2.如何执行2个命令
		andThen();
		//3.如何添加对象
		vote();
		//4.如何包装类方法
		consumermethodref();
		//5.多命令执行
		andthenmore();
	}
	//实例1.基础类型操作
	//使用lambda表达式在此处创建两个Consumer
	//一个odd一个even
	private static void odd_even() {
		//列出2个列表 偶 奇
		List<Integer>oddlist=new ArrayList<>();
		List<Integer>evenlist=new ArrayList<>();
		
		Consumer<Integer>storenumbers=(n)->{
			if(n%2==0) {
				evenlist.add(n);
			}else {
				oddlist.add(n);
			}
		};
		
		Consumer<List<Integer>> printlist=odd_even->odd_even.forEach(n->System.out.println(" "+n));
		storenumbers.accept(424);
		storenumbers.accept(352);
		storenumbers.accept(123);
		storenumbers.accept(445);
		storenumbers.accept(765);
		
		System.out.println("--------evenlist--------");
		printlist.accept(evenlist);
		System.out.println("--------addlist---------");
		printlist.accept(oddlist);
	}
	
	//先创建2个接口对象 在创建1个对象连接 并且 accept 开始执行连接的两个对象。
	private static void andThen() {
		System.out.println("--------andThen-------");
		Consumer<String> c1=(s)->System.out.println(s.toUpperCase());
		Consumer<String> c2=(s)->System.out.println(s.toLowerCase());
		Consumer<String> c1_2=c1.andThen(c2);
		c1_2.accept("Wo Shi Shui");
	}
	
	//实例2：对象类型操作
	//使用lambda表达式创建一个Consumer，它将决定并显示一个公民在选举中是否可以投票的数据。
	private static void vote() {
		List<Citizen> votelist=new ArrayList<>();
		List<Citizen> cantvotelist=new ArrayList<>();
		
		Consumer<Citizen> voteconsumer=c->{
			if(c.getAge()<18||c.getAge()>60) {
				cantvotelist.add(c);
				System.out.println(c.getName()+"can't vote");
			}
			if(c.getAge()>=18 && c.getAge()<=60) {
				votelist.add(c);
				System.out.println(c.getName()+"can vote");
			}
			};
		
		Consumer<List<Citizen>> printlist=v_c->v_c.forEach(c->System.out.println(c));
		voteconsumer.accept(new Citizen("小红",15,0));
		voteconsumer.accept(new Citizen("小黄",18,1));
		voteconsumer.accept(new Citizen("小黑",20,2));
		voteconsumer.accept(new Citizen("小白",12,3));
		voteconsumer.accept(new Citizen("小绿",85,4));
		
		System.out.println("------votelist-----");
		printlist.accept(votelist);
		System.out.println("------cantvotelist-----");
		printlist.accept(cantvotelist);
	}

	//实例3：使用方法引用创建Consumer
	//Consumer可以使用方法引用来创建
	//在我们的例子中，我们有一个有两个方法的使用类Utility，其中一个方法将替代Map中的值，第二个方法
	//显示Map中的数据。我们将使用方法引用来创建Consumer.
	private static void consumermethodref(){
		Map<Integer,String> persons=new HashMap<>();
		persons.put(100, "Tom");
		persons.put(101,"Lucy");
		
		Consumer<Map<Integer,String>> updateperson=Utility::updateData;
		Consumer<Map<Integer,String>> displayperson=Utility::displayData;
		
		updateperson.accept(persons);
		displayperson.accept(persons);
	}
	private static void andthen() {
		//将数组-arraylist（3，4，5，6） 包装成 整数列表 numlist
		List<Integer> numList=Arrays.asList(3,4,5,6);
		//把列表的每个数组 改成 原来数字的平方 并包装成 squareconsumer  
		//consumer 需要一个容器+类型（包装类）
		Consumer<List<Integer>>squareConsumer=list->{
			for(int i=0;i<list.size();i++) {
				list.set(i, list.get(i)*list.get(i));
			}
		};
		//包装方式：容器List 类型 ：Integer 对象： printConsuer
		//numlist的引用：list ，遍历并打印
		Consumer<List<Integer>> printConsumer=
				list->list.forEach(n->System.out.println(n));
		
		// squareConsumer 负责改变value  -> printConsumer 负责打印遍历结果 (他们都接收 源数组 numlist)	
		squareConsumer.andThen(printConsumer).accept(numList);
	}
	private static void andthenmore() {
		List <Integer> list=Arrays.asList(32,32,14,42,523,32,33,12);
		Consumer <List<Integer>> printoddlist=Mynumber::printoddNum;
		Consumer <List<Integer>> printevenlist=Mynumber::printevenNum;
		Consumer <List<Integer>> taskFinlishMsg=Mynumber::taskFinlishMsg;
		printoddlist.andThen(printevenlist).andThen(taskFinlishMsg).accept(list);
	}
}

//2
class Citizen{
	private String name;
	private int age;
	private int id;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public Citizen(String name, int age, int id) {
		super();
		this.name = name;
		this.age = age;
		this.id = id;
	}
	@Override
	public String toString() {
		return "Citizen [name=" + name + ", age=" + age + ", id=" + id + "]";
	}
	
	
}

//3
class Utility{
	static void updateData(Map<Integer,String> persons) {
		persons.replaceAll((k,v)->"更新前: "+v.concat("  	更新后: ".concat(v.concat("1"))));
	}
	
	static void displayData(Map<Integer,String> persons) {
		for(Map.Entry<Integer,String> entry:persons.entrySet()) {
			System.out.println(entry.getKey()+" - "+entry.getValue());
		}
	}
}

//5
class Mynumber{
	static void printoddNum(List<Integer> mynumbers) {
		System.out.println("-------odd numbers-------");
		mynumbers.forEach(n->{
			if(n%2==1) {
				System.out.print(n+" ");
			}
		});
	}
	
	static void printevenNum(List<Integer> mynumbers) {
		System.out.println("\n-------even numbers-------");
		mynumbers.forEach(n->{
			if(n%2==0) {
				System.out.print(n+" ");
			}
		});
	}
	static void taskFinlishMsg(List<Integer> mynumbers) {
		System.out.println("\nTotal "+mynumbers.size()+" number processed.");
	}
}
*/